home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / hplip / unload.py < prev   
Text File  |  2008-10-13  |  29KB  |  917 lines
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19. #
  20. # Author: Don Welch
  21. #
  22.  
  23. __version__ = '3.3'
  24. __title__ = 'Photo Card Access Utility'
  25. __doc__ = "Access inserted photo cards on supported HPLIP printers. This provides an alternative for older devices that do not support USB mass storage or for access to photo cards over a network."
  26.  
  27. # Std Lib
  28. import sys
  29. import os
  30. import os.path
  31. import getopt
  32. import re
  33. import cmd
  34. import time
  35. import fnmatch
  36. import string
  37. import operator
  38.  
  39. try:
  40.     import readline
  41. except ImportError:
  42.     pass
  43.  
  44. # Local
  45. from base.g import *
  46. from base import device, utils, tui
  47. from prnt import cups
  48. from pcard import photocard
  49.  
  50. log.set_module('hp-unload')
  51.  
  52.  
  53. USAGE = [(__doc__, "", "name", True),
  54.          ("Usage: hp-unload [PRINTER|DEVICE-URI] [MODE] [OPTIONS]", "", "summary", True),
  55.          utils.USAGE_ARGS,
  56.          utils.USAGE_DEVICE,
  57.          utils.USAGE_PRINTER,
  58.          utils.USAGE_SPACE,
  59.          ("[MODE]", "", "header", False),
  60.          ("Enter interactive mode (ftp-like interface):", "-i or --interactive", "option", False),
  61.          ("Enter graphical UI mode:", "-u or --gui (Default)", "option", False),
  62.          ("Run in non-interactive mode (batch mode):", "-n or --non-interactive", "option", False),
  63.          # TODO: File glob(s)
  64.          utils.USAGE_SPACE,
  65.          utils.USAGE_OPTIONS,
  66.          ("Output directory:", "-o<dir> or --output=<dir> (Defaults to current directory)(Only used for non-GUI modes)", "option", False),
  67.          utils.USAGE_BUS1, utils.USAGE_BUS2,
  68.          utils.USAGE_LANGUAGE,
  69.          utils.USAGE_LOGGING1, utils.USAGE_LOGGING2, utils.USAGE_LOGGING3,
  70.          utils.USAGE_HELP,
  71.          utils.USAGE_SPACE,
  72.          utils.USAGE_NOTES,
  73.          utils.USAGE_STD_NOTES1, utils.USAGE_STD_NOTES2, 
  74.          ("3. Use 'help' command at the pcard:> prompt for command help (Interactive mode (-i) only).", "", "note", True),
  75.          ]
  76.  
  77. def usage(typ='text'):
  78.     if typ == 'text':
  79.         utils.log_title(__title__, __version__)
  80.  
  81.     utils.format_text(USAGE, typ, __title__, 'hp-unload', __version__)
  82.     sys.exit(0)
  83.  
  84.  
  85. # Console class (from ASPN Python Cookbook)
  86. # Author:   James Thiele
  87. # Date:     27 April 2004
  88. # Version:  1.0
  89. # Location: http://www.eskimo.com/~jet/python/examples/cmd/
  90. # Copyright (c) 2004, James Thiele
  91.  
  92. class Console(cmd.Cmd):
  93.  
  94.     def __init__(self, pc):
  95.         cmd.Cmd.__init__(self)
  96.         self.intro  = "Type 'help' for a list of commands. Type 'exit' to quit."
  97.         self.pc = pc
  98.         disk_info = self.pc.info()
  99.         pc.write_protect = disk_info[8]
  100.         if pc.write_protect:
  101.             log.warning("Photo card is write protected.")
  102.         self.prompt = log.bold("pcard: %s > " % self.pc.pwd())
  103.  
  104.     # Command definitions
  105.     def do_hist(self, args):
  106.         """Print a list of commands that have been entered"""
  107.         print self._hist
  108.  
  109.     def do_exit(self, args):
  110.         """Exits from the console"""
  111.         return -1
  112.  
  113.     def do_quit(self, args):
  114.         """Exits from the console"""
  115.         return -1
  116.  
  117.     # Command definitions to support Cmd object functionality
  118.     def do_EOF(self, args):
  119.         """Exit on system end of file character"""
  120.         return self.do_exit(args)
  121.  
  122.     def do_help(self, args):
  123.         """Get help on commands
  124.            'help' or '?' with no arguments prints a list of commands for which help is available
  125.            'help <command>' or '? <command>' gives help on <command>
  126.         """
  127.         # The only reason to define this method is for the help text in the doc string
  128.         cmd.Cmd.do_help(self, args)
  129.  
  130.     # Override methods in Cmd object
  131.     def preloop(self):
  132.         """Initialization before prompting user for commands.
  133.            Despite the claims in the Cmd documentaion, Cmd.preloop() is not a stub.
  134.         """
  135.         cmd.Cmd.preloop(self)   # sets up command completion
  136.         self._hist    = []      # No history yet
  137.         self._locals  = {}      # Initialize execution namespace for user
  138.         self._globals = {}
  139.  
  140.     def postloop(self):
  141.         """Take care of any unfinished business.
  142.            Despite the claims in the Cmd documentaion, Cmd.postloop() is not a stub.
  143.         """
  144.         cmd.Cmd.postloop(self)   # Clean up command completion
  145.         print "Exiting..."
  146.  
  147.     def precmd(self, line):
  148.         """ This method is called after the line has been input but before
  149.             it has been interpreted. If you want to modifdy the input line
  150.             before execution (for example, variable substitution) do it here.
  151.         """
  152.         self._hist += [line.strip()]
  153.         return line
  154.  
  155.     def postcmd(self, stop, line):
  156.         """If you want to stop the console, return something that evaluates to true.
  157.            If you want to do some post command processing, do it here.
  158.         """
  159.         return stop
  160.  
  161.     def emptyline(self):
  162.         """Do nothing on empty input line"""
  163.         pass
  164.  
  165.     def default(self, line):
  166.         print log.bold("ERROR: Unrecognized command. Use 'help' to list commands.")
  167.  
  168.     def do_ldir(self, args):
  169.         """ List local directory contents."""
  170.         os.system('ls -l')
  171.  
  172.     def do_lls(self, args):
  173.         """ List local directory contents."""
  174.         os.system('ls -l')
  175.  
  176.     def do_dir(self, args):
  177.         """Synonym for the ls command."""
  178.         return self.do_ls(args)
  179.  
  180.     def do_ls(self, args):
  181.         """List photo card directory contents."""
  182.         args = args.strip().lower()
  183.         files = self.pc.ls(True, args)
  184.  
  185.         total_size = 0
  186.         formatter = utils.TextFormatter(
  187.                 (
  188.                     {'width': 14, 'margin' : 2},
  189.                     {'width': 12, 'margin' : 2, 'alignment' : utils.TextFormatter.RIGHT},
  190.                     {'width': 30, 'margin' : 2},
  191.                 )
  192.             )
  193.  
  194.         print
  195.         print log.bold(formatter.compose(("Name", "Size", "Type")))
  196.  
  197.         num_files = 0
  198.         for d in self.pc.current_directories():
  199.             if d[0] in ('.', '..'):
  200.                 print formatter.compose((d[0], "", "directory"))
  201.             else:
  202.                 print formatter.compose((d[0] + "/", "", "directory"))
  203.  
  204.         for f in self.pc.current_files():
  205.             print formatter.compose((f[0], utils.format_bytes(f[2]), self.pc.classify_file(f[0])))
  206.             num_files += 1
  207.             total_size += f[2]
  208.  
  209.         print log.bold("% d files, %s" % (num_files, utils.format_bytes(total_size, True)))
  210.  
  211.  
  212.     def do_df(self, args):
  213.         """Display free space on photo card.
  214.         Options:
  215.         -h\tDisplay in human readable format
  216.         """
  217.         freespace = self.pc.df()
  218.  
  219.         if args.strip().lower() == '-h':
  220.             fs = utils.format_bytes(freespace)
  221.         else:
  222.             fs = utils.commafy(freespace)
  223.  
  224.         print "Freespace = %s Bytes" % fs
  225.  
  226.  
  227.     def do_cp(self, args, remove_after_copy=False):
  228.         """Copy files from photo card to current local directory.
  229.         Usage:
  230.         \tcp FILENAME(S)|GLOB PATTERN(S)
  231.         Example:
  232.         \tCopy all JPEG and GIF files and a file named thumbs.db from photo card to local directory:
  233.         \tcp *.jpg *.gif thumbs.db
  234.         """
  235.         args = args.strip().lower()
  236.  
  237.         matched_files = self.pc.match_files(args)
  238.  
  239.         if len(matched_files) == 0:
  240.             print "ERROR: File(s) not found."
  241.         else:
  242.             total, delta = self.pc.cp_multiple(matched_files, remove_after_copy, self.cp_status_callback, self.rm_status_callback)
  243.  
  244.             print log.bold("\n%s transfered in %d sec (%d KB/sec)" % (utils.format_bytes(total), delta, (total/1024)/(delta)))
  245.  
  246.     def do_unload(self, args):
  247.         """Unload all image files from photocard to current local directory.
  248.         Note:
  249.         \tSubdirectories on photo card are not preserved
  250.         Options:
  251.         -x\tDon't remove files after copy
  252.         -p\tPrint unload list but do not copy or remove files"""
  253.         args = args.lower().strip().split()
  254.         dont_remove = False
  255.         if '-x' in args:
  256.             if self.pc.write_protect:
  257.                 log.error("Photo card is write protected. -x not allowed.")
  258.                 return
  259.             else:
  260.                 dont_remove = True
  261.  
  262.  
  263.         unload_list = self.pc.get_unload_list()
  264.         print
  265.  
  266.         if len(unload_list) > 0:
  267.             if '-p' in args:
  268.  
  269.                 max_len = 0
  270.                 for u in unload_list:
  271.                     max_len = max(max_len, len(u[0]))
  272.  
  273.                 formatter = utils.TextFormatter(
  274.                         (
  275.                             {'width': max_len+2, 'margin' : 2},
  276.                             {'width': 12, 'margin' : 2, 'alignment' : utils.TextFormatter.RIGHT},
  277.                             {'width': 12, 'margin' : 2},
  278.                         )
  279.                     )
  280.  
  281.                 print
  282.                 print log.bold(formatter.compose(("Name", "Size", "Type")))
  283.  
  284.                 total = 0
  285.                 for u in unload_list:
  286.                      print formatter.compose(('%s' % u[0], utils.format_bytes(u[1]), '%s/%s' % (u[2], u[3])))
  287.                      total += u[1]
  288.  
  289.  
  290.                 print log.bold("Found %d files to unload, %s" % (len(unload_list), utils.format_bytes(total, True)))
  291.             else:
  292.                 print log.bold("Unloading %d files..." % len(unload_list))
  293.                 total, delta, was_cancelled = self.pc.unload(unload_list, self.cp_status_callback, self.rm_status_callback, dont_remove)
  294.                 print log.bold("\n%s unloaded in %d sec (%d KB/sec)" % (utils.format_bytes(total), delta, (total/1024)/delta))
  295.  
  296.         else:
  297.             print "No image, audio, or video files found."
  298.  
  299.  
  300.     def cp_status_callback(self, src, trg, size):
  301.         if size == 1:
  302.             print
  303.             print log.bold("Copying %s..." % src)
  304.         else:
  305.             print "\nCopied %s to %s (%s)..." % (src, trg, utils.format_bytes(size))
  306.  
  307.     def rm_status_callback(self, src):
  308.         print "Removing %s..." % src
  309.  
  310.  
  311.  
  312.     def do_rm(self, args):
  313.         """Remove files from photo card."""
  314.         if self.pc.write_protect:
  315.             log.error("Photo card is write protected. rm not allowed.")
  316.             return
  317.  
  318.         args = args.strip().lower()
  319.  
  320.         matched_files = self.pc.match_files(args)
  321.  
  322.         if len(matched_files) == 0:
  323.             print "ERROR: File(s) not found."
  324.         else:
  325.             for f in matched_files:
  326.                 self.pc.rm(f, False)
  327.  
  328.         self.pc.ls()
  329.  
  330.     def do_mv(self, args):
  331.         """Move files off photocard"""
  332.         if self.pc.write_protect:
  333.             log.error("Photo card is write protected. mv not allowed.")
  334.             return
  335.         self.do_cp(args, True)
  336.  
  337.     def do_lpwd(self, args):
  338.         """Print name of local current/working directory."""
  339.         print os.getcwd()
  340.  
  341.     def do_lcd(self, args):
  342.         """Change current local working directory."""
  343.         try:
  344.             os.chdir(args.strip())
  345.         except OSError:
  346.             print log.bold("ERROR: Directory not found.")
  347.         print os.getcwd()
  348.  
  349.     def do_pwd(self, args):
  350.         """Print name of photo card current/working directory
  351.         Usage:
  352.         \t>pwd"""
  353.         print self.pc.pwd()
  354.  
  355.     def do_cd(self, args):
  356.         """Change current working directory on photo card.
  357.         Note:
  358.         \tYou may only specify one directory level at a time.
  359.         Usage:
  360.         \tcd <directory>
  361.         """
  362.         args = args.lower().strip()
  363.  
  364.         if args == '..':
  365.             if self.pc.pwd() != '/':
  366.                 self.pc.cdup()
  367.  
  368.         elif args == '.':
  369.             pass
  370.  
  371.         elif args == '/':
  372.             self.pc.cd('/')
  373.  
  374.         else:
  375.             matched_dirs = self.pc.match_dirs(args)
  376.  
  377.             if len(matched_dirs) == 0:
  378.                 print "Directory not found"
  379.  
  380.             elif len(matched_dirs) > 1:
  381.                 print "Pattern matches more than one directory"
  382.  
  383.             else:
  384.                 self.pc.cd(matched_dirs[0])
  385.  
  386.         self.prompt = log.bold("pcard: %s > " % self.pc.pwd())
  387.  
  388.     def do_cdup(self, args):
  389.         """Change to parent directory."""
  390.         self.do_cd('..')
  391.  
  392.     #def complete_cd( self, text, line, begidx, endidx ):
  393.     #    print text, line, begidx, endidx
  394.     #    #return "XXX"
  395.  
  396.     def do_cache(self, args):
  397.         """Display current cache entries, or turn cache on/off.
  398.         Usage:
  399.         \tDisplay: cache
  400.         \tTurn on: cache on
  401.         \tTurn off: cache off
  402.         """
  403.         args = args.strip().lower()
  404.  
  405.         if args == 'on':
  406.             self.pc.cache_control(True)
  407.  
  408.         elif args == 'off':
  409.             self.pc.cache_control(False)
  410.  
  411.         else:
  412.             if self.pc.cache_state():
  413.                 cache_info = self.pc.cache_info()
  414.  
  415.                 t = cache_info.keys()
  416.                 t.sort()
  417.                 print
  418.                 for s in t:
  419.                     print "sector %d (%d hits)" % (s, cache_info[s])
  420.  
  421.                 print log.bold("Total cache usage: %s (%s maximum)" % (utils.format_bytes(len(t)*512), utils.format_bytes(photocard.MAX_CACHE * 512)))
  422.                 print log.bold("Total cache sectors: %s of %s" % (utils.commafy(len(t)), utils.commafy(photocard.MAX_CACHE)))
  423.             else:
  424.                 print "Cache is off."
  425.  
  426.     def do_sector(self, args):
  427.         """Display sector data.
  428.         Usage:
  429.         \tsector <sector num>
  430.         """
  431.         args = args.strip().lower()
  432.         cached = False
  433.         try:
  434.             sector = int(args)
  435.         except ValueError:
  436.             print "Sector must be specified as a number"
  437.             return
  438.  
  439.         if self.pc.cache_check(sector) > 0:
  440.             print "Cached sector"
  441.  
  442.         print repr(self.pc.sector(sector))
  443.  
  444.  
  445.     def do_tree(self, args):
  446.         """Display photo card directory tree."""
  447.         tree = self.pc.tree()
  448.         print
  449.         self.print_tree(tree)
  450.  
  451.     def print_tree(self, tree, level=0):
  452.         for d in tree:
  453.             if type(tree[d]) == type({}):
  454.                 print ''.join([' '*level*4, d, '/'])
  455.                 self.print_tree(tree[d], level+1)
  456.  
  457.  
  458.     def do_reset(self, args):
  459.         """Reset the cache."""
  460.         self.pc.cache_reset()
  461.  
  462.  
  463.     def do_card(self, args):
  464.         """Print info about photocard."""
  465.         print
  466.         print "Device URI = %s" % self.pc.device.device_uri
  467.         print "Model = %s" % self.pc.device.model_ui
  468.         print "Working dir = %s" % self.pc.pwd()
  469.         disk_info = self.pc.info()
  470.         print "OEM ID = %s" % disk_info[0]
  471.         print "Bytes/sector = %d" % disk_info[1]
  472.         print "Sectors/cluster = %d" % disk_info[2]
  473.         print "Reserved sectors = %d" % disk_info[3]
  474.         print "Root entries = %d" % disk_info[4]
  475.         print "Sectors/FAT = %d" % disk_info[5]
  476.         print "Volume label = %s" % disk_info[6]
  477.         print "System ID = %s" % disk_info[7]
  478.         print "Write protected = %d" % disk_info[8]
  479.         print "Cached sectors = %s" % utils.commafy(len(self.pc.cache_info()))
  480.  
  481.  
  482.     def do_display(self, args):
  483.         """Display an image with ImageMagick.
  484.         Usage:
  485.         \tdisplay <filename>"""
  486.         args = args.strip().lower()
  487.         matched_files = self.pc.match_files(args)
  488.  
  489.         if len(matched_files) == 1:
  490.  
  491.             typ = self.pc.classify_file(args).split('/')[0]
  492.  
  493.             if typ == 'image':
  494.                 fd, temp_name = utils.make_temp_file()
  495.                 self.pc.cp(args, temp_name)
  496.                 os.system('display %s' % temp_name)
  497.                 os.remove(temp_name)
  498.  
  499.             else:
  500.                 print "File is not an image."
  501.  
  502.         elif len(matched_files) == 0:
  503.             print "File not found."
  504.  
  505.         else:
  506.             print "Only one file at a time may be specified for display."
  507.  
  508.     def do_show(self, args):
  509.         """Synonym for the display command."""
  510.         self.do_display(args)
  511.  
  512.     def do_thumbnail(self, args):
  513.         """Display an embedded thumbnail image with ImageMagick.
  514.         Note:
  515.         \tOnly works with JPEG/JFIF images with embedded JPEG/TIFF thumbnails
  516.         Usage:
  517.         \tthumbnail <filename>"""
  518.         args = args.strip().lower()
  519.         matched_files = self.pc.match_files(args)
  520.  
  521.         if len(matched_files) == 1:
  522.             typ, subtyp = self.pc.classify_file(args).split('/')
  523.  
  524.             if typ == 'image' and subtyp in ('jpeg', 'tiff'):
  525.                 exif_info = self.pc.get_exif(args)
  526.  
  527.                 dir_name, file_name=os.path.split(args)
  528.                 photo_name, photo_ext=os.path.splitext(args)
  529.  
  530.                 if 'JPEGThumbnail' in exif_info:
  531.                     temp_file_fd, temp_file_name = utils.make_temp_file()
  532.                     open(temp_file_name, 'wb').write(exif_info['JPEGThumbnail'])
  533.                     os.system('display %s' % temp_file_name)
  534.                     os.remove(temp_file_name)
  535.  
  536.                 elif 'TIFFThumbnail' in exif_info:
  537.                     temp_file_fd, temp_file_name = utils.make_temp_file()
  538.                     open(temp_file_name, 'wb').write(exif_info['TIFFThumbnail'])
  539.                     os.system('display %s' % temp_file_name)
  540.                     os.remove(temp_file_name)
  541.  
  542.                 else:
  543.                     print "No thumbnail found."
  544.  
  545.             else:
  546.                 print "Incorrect file type for thumbnail."
  547.  
  548.         elif len(matched_files) == 0:
  549.             print "File not found."
  550.         else:
  551.             print "Only one file at a time may be specified for thumbnail display."
  552.  
  553.     def do_thumb(self, args):
  554.         """Synonym for the thumbnail command."""
  555.         self.do_thumbnail(args)
  556.  
  557.     def do_exif(self, args):
  558.         """Display EXIF info for file.
  559.         Usage:
  560.         \texif <filename>"""
  561.         args = args.strip().lower()
  562.         matched_files = self.pc.match_files(args)
  563.  
  564.         if len(matched_files) == 1:
  565.             typ, subtyp = self.pc.classify_file(args).split('/')
  566.             #print "'%s' '%s'" % (typ, subtyp)
  567.  
  568.             if typ == 'image' and subtyp in ('jpeg', 'tiff'):
  569.                 exif_info = self.pc.get_exif(args)
  570.  
  571.                 formatter = utils.TextFormatter(
  572.                         (
  573.                             {'width': 40, 'margin' : 2},
  574.                             {'width': 40, 'margin' : 2},
  575.                         )
  576.                     )
  577.  
  578.                 print
  579.                 print log.bold(formatter.compose(("Tag", "Value")))
  580.  
  581.                 ee = exif_info.keys()
  582.                 ee.sort()
  583.                 for e in ee:
  584.                     if e not in ('JPEGThumbnail', 'TIFFThumbnail', 'Filename'):
  585.                         #if e != 'EXIF MakerNote':
  586.                         print formatter.compose((e, '%s' % exif_info[e]))
  587.                         #else:
  588.                         #    print formatter.compose( ( e, ''.join( [ chr(x) for x in exif_info[e].values if chr(x) in string.printable ] ) ) )
  589.             else:
  590.                 print "Incorrect file type for thumbnail."
  591.  
  592.         elif len(matched_files) == 0:
  593.             print "File not found."
  594.         else:
  595.             print "Only one file at a time may be specified for thumbnail display."
  596.  
  597.     def do_info(self, args):
  598.         """Synonym for the exif command."""
  599.         self.do_exif(args)
  600.  
  601.     def do_about(self, args):
  602.         utils.log_title(__title__, __version__)
  603.  
  604.  
  605. def status_callback(src, trg, size):
  606.     if size == 1:
  607.         print
  608.         print log.bold("Copying %s..." % src)
  609.     else:
  610.         print "\nCopied %s to %s (%s)..." % (src, trg, utils.format_bytes(size))
  611.  
  612.  
  613.  
  614. try:
  615.     opts, args = getopt.getopt(sys.argv[1:], 'p:d:hb:l:giuno:q:',
  616.                                ['printer=', 'device=', 'help', 'help-rest', 'help-man',
  617.                                 'bus=', 'logging=', 'interactive', 'gui', 'non-interactive',
  618.                                 'output=', 'help-desc', 'lang='])
  619. except getopt.GetoptError, e:
  620.     log.error(e.msg)
  621.     usage()
  622.  
  623. printer_name = None
  624. device_uri = None
  625. bus = device.DEFAULT_PROBE_BUS
  626. log_level = logger.DEFAULT_LOG_LEVEL
  627. mode = GUI_MODE
  628. mode_specified = False
  629. output_dir = os.getcwd()
  630. loc = None
  631.  
  632. if os.getenv("HPLIP_DEBUG"):
  633.     log.set_level('debug')
  634.  
  635. for o, a in opts:
  636.     if o in ('-h', '--help'):
  637.         usage()
  638.  
  639.     elif o == '--help-rest':
  640.         usage('rest')
  641.  
  642.     elif o == '--help-man':
  643.         usage('man')
  644.  
  645.     elif o == '--help-desc':
  646.         print __doc__,
  647.         sys.exit(0)
  648.  
  649.     elif o in ('-p', '--printer'):
  650.         if a.startswith('*'):
  651.             printer_name = cups.getDefaultPrinter()
  652.             log.debug(printer_name)
  653.             
  654.             if printer_name is not None:
  655.                 log.info("Using CUPS default printer: %s" % printer_name)
  656.             else:
  657.                 log.error("CUPS default printer is not set.")
  658.             
  659.         else:
  660.             printer_name = a
  661.  
  662.     elif o in ('-d', '--device'):
  663.         device_uri = a
  664.  
  665.     elif o in ('-b', '--bus'):
  666.         bus = [x.lower().strip() for x in a.split(',')]
  667.         if not device.validateBusList(bus):
  668.             usage()
  669.  
  670.     elif o in ('-l', '--logging'):
  671.         log_level = a.lower().strip()
  672.         if not log.set_level(log_level):
  673.             usage()
  674.  
  675.     elif o == '-g':
  676.         log.set_level('debug')
  677.  
  678.     elif o in ('-i', '--interactive'):
  679.         if mode_specified:
  680.             log.error("You may only specify a single mode as a parameter (-i, -n or -u).")
  681.             sys.exit(1)
  682.  
  683.         mode = INTERACTIVE_MODE
  684.         mode_specified = True
  685.  
  686.     elif o in ('-u', '--gui'):
  687.         if mode_specified:
  688.             log.error("You may only specify a single mode as a parameter (-i, -n or -u).")
  689.             sys.exit(1)
  690.  
  691.         mode = GUI_MODE
  692.         mode_specified = True
  693.  
  694.     elif o in ('-n', '--non-interactive'):
  695.         if mode_specified:
  696.             log.error("You may only specify a single mode as a parameter (-i, -n or -u).")
  697.             sys.exit(1)
  698.  
  699.         mode = NON_INTERACTIVE_MODE
  700.         mode_specified = True
  701.  
  702.     elif o in ('-o', '--output'):
  703.         output_dir = a
  704.  
  705.     elif o in ('-q', '--lang'):
  706.         if a.strip() == '?':
  707.             tui.show_languages()
  708.             sys.exit(0)
  709.  
  710.         loc = utils.validate_language(a.lower())
  711.  
  712.  
  713. utils.log_title(__title__, __version__)
  714.  
  715. if os.getuid() == 0:
  716.     log.warn("hp-unload should not be run as root.")
  717.  
  718. # Security: Do *not* create files that other users can muck around with
  719. os.umask (0037)
  720.  
  721. if mode == GUI_MODE:
  722.     if not utils.canEnterGUIMode():
  723.         mode = INTERACTIVE_MODE
  724.  
  725. if mode in (INTERACTIVE_MODE, NON_INTERACTIVE_MODE):
  726.     try:
  727.         if device_uri and printer_name:
  728.             log.error("You may not specify both a printer (-p) and a device (-d).")
  729.             usage()
  730.  
  731.  
  732.         if printer_name:
  733.             printer_list = cups.getPrinters()
  734.             found = False
  735.             for p in printer_list:
  736.                 if p.name == printer_name:
  737.                     found = True
  738.  
  739.             if not found:
  740.                 log.error("Unknown printer name: %s" % printer_name)
  741.                 sys.exit(1)
  742.  
  743.  
  744.         if not device_uri and not printer_name:
  745.             try:
  746.                 device_uri = device.getInteractiveDeviceURI(bus, {'pcard-type' : (operator.gt, 0)})
  747.                 if device_uri is None:
  748.                     sys.exit(1)
  749.             except Error:
  750.                 log.error("Error occured during interactive mode. Exiting.")
  751.                 sys.exit(1)
  752.  
  753.         try:
  754.             pc = photocard.PhotoCard( None, device_uri, printer_name )
  755.         except Error, e:
  756.             log.error("Unable to start photocard session: %s" % e.msg)
  757.             sys.exit(1)
  758.  
  759.         pc.set_callback(update_spinner)
  760.  
  761.         if pc.device.device_uri is None and printer_name:
  762.             log.error("Printer '%s' not found." % printer_name)
  763.             sys.exit(1)
  764.  
  765.         if pc.device.device_uri is None and device_uri:
  766.             log.error("Malformed/invalid device-uri: %s" % device_uri)
  767.             sys.exit(1)
  768.  
  769.         user_cfg.last_used.device_uri = pc.device.device_uri
  770.  
  771.         # TODO: 
  772.         #pc.device.sendEvent(EVENT_START_PCARD_JOB)
  773.  
  774.         try:
  775.             pc.mount()
  776.         except Error:
  777.             log.error("Unable to mount photo card on device. Check that device is powered on and photo card is correctly inserted.")
  778.             pc.umount()
  779.             # TODO:
  780.             #pc.device.sendEvent(EVENT_PCARD_UNABLE_TO_MOUNT, typ='error')
  781.             sys.exit(1)
  782.  
  783.         log.info(log.bold("\nPhotocard on device %s mounted" % pc.device.device_uri))
  784.         log.info(log.bold("DO NOT REMOVE PHOTO CARD UNTIL YOU EXIT THIS PROGRAM"))
  785.  
  786.         output_dir = os.path.realpath(os.path.normpath(os.path.expanduser(output_dir)))
  787.  
  788.         try:
  789.             os.chdir(output_dir)
  790.         except OSError:
  791.             print log.bold("ERROR: Output directory %s not found." % output_dir)
  792.             sys.exit(1)
  793.  
  794.  
  795.  
  796.         if mode == INTERACTIVE_MODE: # INTERACTIVE_MODE
  797.  
  798.             console = Console(pc)
  799.             try:
  800.                 try:
  801.                     console . cmdloop()
  802.                 except KeyboardInterrupt:
  803.                     log.error("Aborted.")
  804.                 except Exception, e:
  805.                     log.error("An error occured: %s" % e)
  806.             finally:
  807.                 pc.umount()
  808.  
  809.             # TODO:
  810.             #pc.device.sendEvent(EVENT_END_PCARD_JOB)
  811.  
  812.  
  813.         else: # NON_INTERACTIVE_MODE
  814.             print "Output directory is %s" % os.getcwd()
  815.             try:
  816.                 unload_list = pc.get_unload_list()
  817.                 print
  818.  
  819.                 if len(unload_list) > 0:
  820.  
  821.                     max_len = 0
  822.                     for u in unload_list:
  823.                         max_len = max(max_len, len(u[0]))
  824.  
  825.                     formatter = utils.TextFormatter(
  826.                             (
  827.                                 {'width': max_len+2, 'margin' : 2},
  828.                                 {'width': 12, 'margin' : 2, 'alignment' : utils.TextFormatter.RIGHT},
  829.                                 {'width': 12, 'margin' : 2},
  830.                             )
  831.                         )
  832.  
  833.                     print
  834.                     print log.bold(formatter.compose(("Name", "Size", "Type")))
  835.  
  836.                     total = 0
  837.                     for u in unload_list:
  838.                          print formatter.compose(('%s' % u[0], utils.format_bytes(u[1]), '%s/%s' % (u[2], u[3])))
  839.                          total += u[1]
  840.  
  841.  
  842.                     print log.bold("Found %d files to unload, %s\n" % (len(unload_list), utils.format_bytes(total, True)))
  843.                     print log.bold("Unloading files...\n")
  844.                     total, delta, was_cancelled = pc.unload(unload_list, status_callback, None, True)
  845.                     print log.bold("\n%s unloaded in %d sec (%d KB/sec)" % (utils.format_bytes(total), delta, (total/1024)/delta))
  846.  
  847.  
  848.             finally:
  849.                 pc.umount()
  850.  
  851.     except KeyboardInterrupt:
  852.         log.error("User exit")
  853.  
  854.  
  855. else: # GUI_MODE
  856.  
  857.     from qt import *
  858.     from ui import unloadform
  859.  
  860.     app = QApplication(sys.argv)
  861.     QObject.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
  862.  
  863.     if loc is None:
  864.         loc = user_cfg.ui.get("loc", "system")
  865.         if loc.lower() == 'system':
  866.             loc = str(QTextCodec.locale())
  867.             log.debug("Using system locale: %s" % loc)
  868.  
  869.     if loc.lower() != 'c':
  870.         e = 'utf8'
  871.         try:
  872.             l, x = loc.split('.')
  873.             loc = '.'.join([l, e])
  874.         except ValueError:
  875.             l = loc
  876.             loc = '.'.join([loc, e])
  877.  
  878.         log.debug("Trying to load .qm file for %s locale." % loc)
  879.         trans = QTranslator(None)
  880.  
  881.         qm_file = 'hplip_%s.qm' % l
  882.         log.debug("Name of .qm file: %s" % qm_file)
  883.         loaded = trans.load(qm_file, prop.localization_dir)
  884.  
  885.         if loaded:
  886.             app.installTranslator(trans)
  887.         else:
  888.             loc = 'c'
  889.  
  890.     if loc == 'c':
  891.         log.debug("Using default 'C' locale")
  892.     else:
  893.         log.debug("Using locale: %s" % loc)
  894.         QLocale.setDefault(QLocale(loc))
  895.         prop.locale = loc
  896.         try:
  897.             locale.setlocale(locale.LC_ALL, locale.normalize(loc))
  898.         except locale.Error:
  899.             pass 
  900.  
  901.  
  902.     try:
  903.         w = unloadform.UnloadForm(bus, device_uri, printer_name)
  904.     except Error:
  905.         log.error("Unable to connect to HPLIP I/O. Please (re)start HPLIP and try again.")
  906.         sys.exit(1)
  907.  
  908.     app.setMainWidget(w)
  909.     w.show()
  910.  
  911.     app.exec_loop()
  912.  
  913. log.info("")
  914. log.info("Done.")
  915.  
  916.  
  917.